home *** CD-ROM | disk | FTP | other *** search
/ Aminet 51 / Aminet 51 (2002)(GTI - Schatztruhe)[!][Oct 2002].iso / Aminet / gfx / fract / FlashMandelWOS.lha / FlashMandel / Developer / Modules / React / FM_SysInfoReq_React.c < prev   
Encoding:
C/C++ Source or Header  |  2002-08-02  |  5.8 KB  |  224 lines
  1. /*
  2.  *  FM_SysInfoReq_React.c
  3.  *
  4.  *  Requester for sysinfo-request with reaction-support
  5.  *  $VER: V2.0, 13.10.2001
  6.  *  Coded by Edgar Schwan
  7.  */
  8.  
  9. #include <intuition/gadgetclass.h>
  10. #include <intuition/classusr.h>
  11. #include <intuition/screens.h>
  12. #include <classes/window.h>
  13. #include <dos/dos.h>
  14. #include <gadgets/string.h>
  15.  
  16. #include <clib/intuition_protos.h>
  17. #include <clib/exec_protos.h>
  18. #include <clib/graphics_protos.h>
  19. #include <clib/alib_protos.h>
  20.  
  21. #include <pragmas/intuition_pragmas.h>
  22. #include <pragmas/exec_pragmas.h>
  23. #include <pragmas/graphics_pragmas.h>
  24.  
  25. #include <stdlib.h>
  26. #include <stdio.h>
  27.  
  28. #include "FM_SysInfoReq_React.h"
  29. #include "FM_ReactionBasics.h"
  30. #include "FM_Reaction.h"
  31. #include "FM_ReactionCD.h"
  32.  
  33. extern ULONG *PALETTE;
  34.  
  35. extern TEXT CPU68K_STR;
  36. extern TEXT FPU68K_STR;
  37. extern TEXT CPUPPC_STR;
  38. extern TEXT FPUPPC_STR;
  39.  
  40. struct ReactWinData *sysinfo_rwd = NULL;
  41.  
  42. /*    Do_SysInfoRequest(): sysinfo-requester (full handling).
  43.  
  44.         SYNOPSIS: void = Do_SysInfoRequest
  45.                         (
  46.                         struct Window      *Win;
  47.                         char                  *PubScreenName;
  48.                         WORD                     Left;
  49.                         WORD                    Top;
  50.                         );
  51.  
  52.         INPUTS:        Win:
  53.                             Pointer to the parent-window.
  54.  
  55.                         PubScreenName:
  56.                             name of the public-screen, where the window should appear.
  57.  
  58.                         Left:
  59.                             Left edge of palette-window.
  60.  
  61.                         Top:
  62.                             Top edge of palette-window.
  63.  
  64.         RETURNS:        -
  65. */
  66.  
  67. void Do_SysInfoRequest(struct Window *Win, char *PubScreenName, WORD Left, WORD Top)
  68. {
  69. LONG result = RESULT_NOTHING;
  70. ULONG waitsigs, mask;
  71.  
  72. if (OpenSysInfoReqWindow(PubScreenName) == TRUE) {
  73.     waitsigs = sysinfo_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;
  74.  
  75.     while(result == RESULT_NOTHING) {
  76.         mask = Wait(waitsigs);
  77. #ifndef NDEBUG
  78.         printf("mask: %lX\n", mask);
  79. #endif /*NDEBUG*/
  80.         if (mask & sysinfo_rwd->RWD_WSignals) {
  81.             result = HandleSysInfoReqWindow(Win);
  82.             }
  83.         if (mask & SIGBREAKF_CTRL_C) {
  84.             result = RESULT_CANCEL;
  85.             }
  86.         }
  87.  
  88.     CloseSysInfoReqWindow();
  89.     } else DisplayError(Win, TXT_ERR_Window, 5L);
  90.  
  91. LoadRGB32(ViewPortAddress (Win), (APTR) PALETTE);
  92. }
  93.  
  94. /*    OpenSysInfoReqWindow(): open window of sysinfo-requester.
  95.  
  96.         SYNOPSIS: BOOL res = OpenSysInfoReqWindow
  97.                         (
  98.                         char    *PubScreenName;
  99.                         );
  100.  
  101.         INPUTS:        PubScreenName:
  102.                             name of the public-screen, where the window should appear.
  103.  
  104.         RETURNS:        res:
  105.                             TRUE, if successfull.
  106. */
  107.  
  108. BOOL OpenSysInfoReqWindow(char *PubScreenName)
  109. {
  110. if (sysinfo_rwd = OpenReactionWindow(WIN_SYSI_ID, GROUP_SysI_ID, PubScreenName)) {
  111.     ULONG chip = AvailMem(MEMF_CHIP);
  112.     ULONG fast = AvailMem(MEMF_FAST);
  113.     ULONG largestchip = AvailMem(MEMF_CHIP|MEMF_LARGEST);
  114.     ULONG largestfast = AvailMem(MEMF_FAST|MEMF_LARGEST);
  115.    char buffer[20];
  116.  
  117.     SetGadgetAttrs(sysinfo_rwd->RWD_GadgetArray[SysI_STRING_68kCPU], sysinfo_rwd->RWD_IWindow, NULL,
  118.                         STRINGA_TextVal, &CPU68K_STR, TAG_DONE);
  119.     SetGadgetAttrs(sysinfo_rwd->RWD_GadgetArray[SysI_STRING_68kFPU], sysinfo_rwd->RWD_IWindow, NULL,
  120.                         STRINGA_TextVal, &FPU68K_STR, TAG_DONE);
  121.     SetGadgetAttrs(sysinfo_rwd->RWD_GadgetArray[SysI_STRING_PPCCPU], sysinfo_rwd->RWD_IWindow, NULL,
  122.                         STRINGA_TextVal, &CPUPPC_STR, TAG_DONE);
  123.     SetGadgetAttrs(sysinfo_rwd->RWD_GadgetArray[SysI_STRING_PPCFPU], sysinfo_rwd->RWD_IWindow, NULL,
  124.                         STRINGA_TextVal, &FPUPPC_STR, TAG_DONE);
  125.     sprintf((char *) &buffer, "%ld", chip);
  126.     SetGadgetAttrs(sysinfo_rwd->RWD_GadgetArray[SysI_STRING_AvailChip], sysinfo_rwd->RWD_IWindow, NULL,
  127.                         STRINGA_TextVal, &buffer, TAG_DONE);
  128.     sprintf((char *) &buffer, "%ld", fast);
  129.     SetGadgetAttrs(sysinfo_rwd->RWD_GadgetArray[SysI_STRING_AvailFast], sysinfo_rwd->RWD_IWindow, NULL,
  130.                         STRINGA_TextVal, &buffer, TAG_DONE);
  131.     sprintf((char *) &buffer, "%ld", largestchip);
  132.     SetGadgetAttrs(sysinfo_rwd->RWD_GadgetArray[SysI_STRING_LargestChip], sysinfo_rwd->RWD_IWindow, NULL,
  133.                         STRINGA_TextVal, &buffer, TAG_DONE);
  134.     sprintf((char *) &buffer, "%ld", largestfast);
  135.     SetGadgetAttrs(sysinfo_rwd->RWD_GadgetArray[SysI_STRING_LargestFast], sysinfo_rwd->RWD_IWindow, NULL,
  136.                         STRINGA_TextVal, &buffer, TAG_DONE);
  137.     return(TRUE);
  138.     }
  139. return(FALSE);
  140. }
  141.  
  142. /*    CloseSysInfoReqWindow(): close window of sysinfo-requester.
  143.  
  144.         SYNOPSIS: void = CloseSysInfoReqWindow
  145.                         (
  146.                         void
  147.                         );
  148.  
  149.         INPUTS:        -
  150.  
  151.         RETURNS:        -
  152. */
  153.  
  154. void CloseSysInfoReqWindow(void)
  155. {
  156. CloseReactionWindow(sysinfo_rwd);
  157. }
  158.  
  159. /*    HandleSysInfoReqWindow(): Handle the messages of the sysinfo-requester.
  160.  
  161.         SYNOPSIS: LONG res = HandlePalettePrefWindow
  162.                         (
  163.                         struct Window    *Win;
  164.                         );
  165.  
  166.         INPUTS:        Win:
  167.                             Pointer to a window-structure.
  168.  
  169.         RETURNS:        res:
  170.                             result of messages:    RESULT_NOTHING -> nothing happens.
  171.                                                         RESULT_CANCEL  -> user wants to quit without a change.
  172.                                                         RESULT_OK      -> accept changes and quit.
  173. */
  174.  
  175. LONG HandleSysInfoReqWindow(struct Window *Win)
  176. {
  177. LONG rc = RESULT_NOTHING;
  178. ULONG result, code;
  179.  
  180. while((result = DoMethod(sysinfo_rwd->RWD_WindowObject, WM_HANDLEINPUT, &code)) != WMHI_LASTMSG) {
  181.  
  182. #ifndef NDEBUG
  183.     printf("result: %ld\n", result);
  184. #endif /*NDEBUG*/
  185.  
  186.     switch (result & WMHI_CLASSMASK) {
  187.         case WMHI_CLOSEWINDOW:
  188.             rc = RESULT_CANCEL;
  189.             break;
  190.  
  191.         case WMHI_GADGETUP:
  192.             switch (result & RL_GADGETMASK) {
  193.                 case SysI_BUTTON_OK:
  194.                     rc = RESULT_OK;
  195.                     break;
  196. #ifndef NDEBUG
  197.                 default:
  198.                     printf("unknown result: %lX\nunknown gadget: %lX\n", result, result & WMHI_GADGETMASK);
  199.                     DisplayBeep(NULL);
  200.                     break;
  201. #endif /*NDEBUG*/
  202.                 }
  203.             break;
  204.  
  205.         case WMHI_ICONIFY:
  206.             DoMethod(sysinfo_rwd->RWD_WindowObject, WM_ICONIFY);
  207.             GetAttr(WINDOW_Window, sysinfo_rwd->RWD_WindowObject, (ULONG *) &sysinfo_rwd->RWD_IWindow);
  208.             break;
  209.  
  210.         case WMHI_UNICONIFY:
  211.             DoMethod(sysinfo_rwd->RWD_WindowObject, WM_OPEN);
  212.             GetAttr(WINDOW_Window, sysinfo_rwd->RWD_WindowObject, (ULONG *) &sysinfo_rwd->RWD_IWindow);
  213.             break;
  214. #ifndef NDEBUG
  215.         default:
  216.             printf("unknown result: %lX\nunknown class: %lX\n", result, result & WMHI_CLASSMASK);
  217.             DisplayBeep(NULL);
  218.             break;
  219. #endif /*NDEBUG*/
  220.         }
  221.     }
  222. return(rc);
  223. }
  224.